home *** CD-ROM | disk | FTP | other *** search
/ Apple WWDC 1996 / WWDC96_1996 (CD).toast / Technology Materials / MacOS 8 Resources / Developer Tools / Mac OS 8 Interfaces & Libraries / Interfaces / PInterfaces / TextEdit.p < prev    next >
Text File  |  1996-05-01  |  32KB  |  907 lines
  1. {
  2.      File:        TextEdit.p
  3.  
  4.      Contains:    TextEdit Interfaces.
  5.  
  6.      Version:    Technology:    System 7.5
  7.                  Release:    Universal Interfaces 3.0d3 on Copland DR1
  8.  
  9.      Copyright:    © 1984-1996 by Apple Computer, Inc.  All rights reserved.
  10.  
  11.      Bugs?:        If you find a problem with this file, send the file and version
  12.                  information (from above) and the problem description to:
  13.  
  14.                      Internet:    apple.bugs@applelink.apple.com
  15.                      AppleLink:    APPLE.BUGS
  16.  
  17. }
  18. {$IFC UNDEFINED UsingIncludes}
  19. {$SETC UsingIncludes := 0}
  20. {$ENDC}
  21.  
  22. {$IFC NOT UsingIncludes}
  23.  UNIT TextEdit;
  24.  INTERFACE
  25. {$ENDC}
  26.  
  27. {$IFC UNDEFINED __TEXTEDIT__}
  28. {$SETC __TEXTEDIT__ := 1}
  29.  
  30. {$I+}
  31. {$SETC TextEditIncludes := UsingIncludes}
  32. {$SETC UsingIncludes := 1}
  33.  
  34. {$IFC UNDEFINED __TYPES__}
  35. {$I Types.p}
  36. {$ENDC}
  37. {$IFC UNDEFINED __QUICKDRAW__}
  38. {$I Quickdraw.p}
  39. {$ENDC}
  40. {$IFC UNDEFINED __MIXEDMODE__}
  41. {$I MixedMode.p}
  42. {$ENDC}
  43. {$IFC UNDEFINED __TEXTOBJECTS__}
  44. {$I TextObjects.p}
  45. {$ENDC}
  46. {$IFC UNDEFINED __TEXTSERVICES__}
  47. {$I TextServices.p}
  48. {$ENDC}
  49.  
  50. {$PUSH}
  51. {$ALIGN MAC68K}
  52. {$LibExport+}
  53.  
  54. {$IFC FOR_SYSTEM7_AND_SYSTEM8_COOPERATIVE }
  55.  
  56. TYPE
  57.     TERecPtr = ^TERec;
  58.     TEPtr                                = ^TERec;
  59.     TEHandle                            = ^TEPtr;
  60.     HighHookProcPtr = Register68kProcPtr;  { PROCEDURE HighHook((CONST)VAR r: Rect; pTE: TEPtr); }
  61.  
  62.     EOLHookProcPtr = Register68kProcPtr;  { FUNCTION EOLHook(theChar: ByteParameter; pTE: TEPtr; hTE: TEHandle): BOOLEAN; }
  63.  
  64.     CaretHookProcPtr = Register68kProcPtr;  { PROCEDURE CaretHook((CONST)VAR r: Rect; pTE: TEPtr); }
  65.  
  66.     WidthHookProcPtr = Register68kProcPtr;  { FUNCTION WidthHook(textLen: INTEGER; textOffset: INTEGER; textBufferPtr: UNIV Ptr; pTE: TEPtr; hTE: TEHandle): INTEGER; }
  67.  
  68.     TextWidthHookProcPtr = Register68kProcPtr;  { FUNCTION TextWidthHook(textLen: INTEGER; textOffset: INTEGER; textBufferPtr: UNIV Ptr; pTE: TEPtr; hTE: TEHandle): INTEGER; }
  69.  
  70.     NWidthHookProcPtr = Register68kProcPtr;  { FUNCTION NWidthHook(styleRunLen: INTEGER; styleRunOffset: INTEGER; slop: INTEGER; direction: INTEGER; textBufferPtr: UNIV Ptr; VAR lineStart: INTEGER; pTE: TEPtr; hTE: TEHandle): INTEGER; }
  71.  
  72.     DrawHookProcPtr = Register68kProcPtr;  { PROCEDURE DrawHook(textOffset: INTEGER; drawLen: INTEGER; textBufferPtr: UNIV Ptr; pTE: TEPtr; hTE: TEHandle); }
  73.  
  74.     HitTestHookProcPtr = Register68kProcPtr;  { FUNCTION HitTestHook(styleRunLen: INTEGER; styleRunOffset: INTEGER; slop: INTEGER; textBufferPtr: UNIV Ptr; pTE: TEPtr; hTE: TEHandle; VAR pixelWidth: INTEGER; VAR charOffset: INTEGER; VAR pixelInChar: BOOLEAN): BOOLEAN; }
  75.  
  76.     TEFindWordProcPtr = Register68kProcPtr;  { PROCEDURE TEFindWord(currentPos: INTEGER; caller: INTEGER; pTE: TEPtr; hTE: TEHandle; VAR wordStart: INTEGER; VAR wordEnd: INTEGER); }
  77.  
  78.     TERecalcProcPtr = Register68kProcPtr;  { PROCEDURE TERecalc(pTE: TEPtr; changeLength: INTEGER; VAR lineStart: INTEGER; VAR firstChar: INTEGER; VAR lastChar: INTEGER); }
  79.  
  80.     TEDoTextProcPtr = Register68kProcPtr;  { PROCEDURE TEDoText(pTE: TEPtr; firstChar: INTEGER; lastChar: INTEGER; selector: INTEGER; VAR currentGrafPort: GrafPtr; VAR charPosition: INTEGER); }
  81.  
  82.     TEClickLoopProcPtr = Register68kProcPtr;  { FUNCTION TEClickLoop(pTE: TEPtr): BOOLEAN; }
  83.  
  84.     WordBreakProcPtr = Register68kProcPtr;  { FUNCTION WordBreak(text: Ptr; charPos: INTEGER): BOOLEAN; }
  85.  
  86. {
  87.     Important note about TEClickLoopProcPtr and WordBreakProcPtr
  88.  
  89.     At one point these were defined as returning the function result in the 
  90.     condition code Z-bit.  This was correct, in that it was what the 68K
  91.     implementation of TextEdit actually tested.  But, MixedMode had a different 
  92.     idea of what returning a boolean in the Z-bit meant.  MixedMode was setting
  93.     the Z-bit the complement of what was wanted.  
  94.     
  95.     Therefore, these ProcPtrs have been changed (back) to return the result in
  96.     register D0.  It turns out that for register based routines, 
  97.     MixedMode sets the Z-bit of the 68K emulator based on the contents 
  98.     of the return result register.  Thus we can get the Z-bit set correctly.  
  99.     
  100.     But, when TextEdit is recoded in PowerPC, if it calls a 68K ClickLoop
  101.     or WordBreak routine, register D0 had better have the result (in addition
  102.     to the Z-bit). Therefore all 68K apps should make sure their ClickLoop or
  103.     WordBreak routines set register D0 at the end.
  104. }
  105. {
  106.     There is no function to get/set the low-mem for FindWordHook at 0x07F8.
  107.     This is because it is not a low-mem ProcPtr. That address is the entry
  108.     in the OS TrapTable for trap 0xA0FE.  You can use Get/SetTrapAddress to 
  109.     acccess it.    
  110. }
  111. {
  112.     The following ProcPtrs cannot be written in or called from a high-level 
  113.     language without the help of mixed mode or assembly glue because they 
  114.     use the following parameter-passing conventions:
  115.  
  116.     typedef pascal void (*HighHookProcPtr)(const Rect *r, TEPtr pTE);
  117.     typedef pascal void (*CaretHookProcPtr)(const Rect *r, TEPtr pTE);
  118.  
  119.         In:
  120.             =>     r                        on stack
  121.             =>    pTE                        A3.L
  122.         Out:
  123.             none
  124.  
  125.     typedef pascal Boolean (*EOLHookProcPtr)(char theChar, TEPtr pTE, TEHandle hTE);
  126.  
  127.         In:
  128.             =>     theChar                    D0.B
  129.             =>    pTE                        A3.L
  130.             =>    hTE                        A4.L
  131.         Out:
  132.             <=    Boolean                    Z bit of the CCR
  133.  
  134.     typedef pascal unsigned short (*WidthHookProcPtr)(unsigned short textLen,
  135.      unsigned short textOffset, void *textBufferPtr, TEPtr pTE, TEHandle hTE);
  136.     typedef pascal unsigned short (*TextWidthHookProcPtr)(unsigned short textLen,
  137.      unsigned short textOffset, void *textBufferPtr, TEPtr pTE, TEHandle hTE);
  138.  
  139.         In:
  140.             =>     textLen                    D0.W
  141.             =>    textOffset                D1.W
  142.             =>    textBufferPtr            A0.L
  143.             =>    pTE                        A3.L
  144.             =>    hTE                        A4.L
  145.         Out:
  146.             <=    unsigned short            D1.W
  147.  
  148.     typedef pascal unsigned short (*NWidthHookProcPtr)(unsigned short styleRunLen,
  149.      unsigned short styleRunOffset, short slop, short direction, void *textBufferPtr, 
  150.      short *lineStart, TEPtr pTE, TEHandle hTE);
  151.  
  152.         In:
  153.             =>     styleRunLen                D0.W
  154.             =>    styleRunOffset            D1.W
  155.             =>    slop                    D2.W (low)
  156.             =>    direction                D2.W (high)
  157.             =>    textBufferPtr            A0.L
  158.             =>    lineStart                A2.L
  159.             =>    pTE                        A3.L
  160.             =>    hTE                        A4.L
  161.         Out:
  162.             <=    unsigned short            D1.W
  163.  
  164.     typedef pascal void (*DrawHookProcPtr)(unsigned short textOffset, unsigned short drawLen,
  165.      void *textBufferPtr, TEPtr pTE, TEHandle hTE);
  166.  
  167.         In:
  168.             =>     textOffset                D0.W
  169.             =>    drawLen                    D1.W
  170.             =>    textBufferPtr            A0.L
  171.             =>    pTE                        A3.L
  172.             =>    hTE                        A4.L
  173.         Out:
  174.             none
  175.  
  176.     typedef pascal Boolean (*HitTestHookProcPtr)(unsigned short styleRunLen,
  177.      unsigned short styleRunOffset, unsigned short slop, void *textBufferPtr,
  178.      TEPtr pTE, TEHandle hTE, unsigned short *pixelWidth, unsigned short *charOffset, 
  179.      Boolean *pixelInChar);
  180.  
  181.         In:
  182.             =>     styleRunLen                D0.W
  183.             =>    styleRunOffset            D1.W
  184.             =>    slop                    D2.W
  185.             =>    textBufferPtr            A0.L
  186.             =>    pTE                        A3.L
  187.             =>    hTE                        A4.L
  188.         Out:
  189.             <=    pixelWidth                D0.W (low)
  190.             <=    Boolean                    D0.W (high)
  191.             <=    charOffset                D1.W
  192.             <=    pixelInChar                D2.W
  193.  
  194.     typedef pascal void (*TEFindWordProcPtr)(unsigned short currentPos, short caller, 
  195.      TEPtr pTE, TEHandle hTE, unsigned short *wordStart, unsigned short *wordEnd);
  196.  
  197.         In:
  198.             =>     currentPos                D0.W
  199.             =>    caller                    D2.W
  200.             =>    pTE                        A3.L
  201.             =>    hTE                        A4.L
  202.         Out:
  203.             <=    wordStart                D0.W
  204.             <=    wordEnd                    D1.W
  205.  
  206.     typedef pascal void (*TERecalcProcPtr)(TEPtr pTE, unsigned short changeLength,
  207.        unsigned short *lineStart, unsigned short *firstChar, unsigned short *lastChar);
  208.  
  209.         In:
  210.             =>     pTE                        A3.L
  211.             =>    changeLength            D7.W
  212.         Out:
  213.             <=    lineStart                D2.W
  214.             <=    firstChar                D3.W
  215.             <=    lastChar                D4.W
  216.  
  217.     typedef pascal void (*TEDoTextProcPtr)(TEPtr pTE, unsigned short firstChar, unsigned short lastChar,
  218.                          short selector, GrafPtr *currentGrafPort, short *charPosition);
  219.  
  220.         In:
  221.             =>     pTE                        A3.L
  222.             =>    firstChar                D3.W
  223.             =>    lastChar                D4.W
  224.             =>    selector                D7.W
  225.         Out:
  226.             <=    currentGrafPort            A0.L
  227.             <=    charPosition            D0.W
  228.             
  229. }
  230.     HighHookUPP = UniversalProcPtr;
  231.     EOLHookUPP = UniversalProcPtr;
  232.     CaretHookUPP = UniversalProcPtr;
  233.     WidthHookUPP = UniversalProcPtr;
  234.     TextWidthHookUPP = UniversalProcPtr;
  235.     NWidthHookUPP = UniversalProcPtr;
  236.     DrawHookUPP = UniversalProcPtr;
  237.     HitTestHookUPP = UniversalProcPtr;
  238.     TEFindWordUPP = UniversalProcPtr;
  239.     TERecalcUPP = UniversalProcPtr;
  240.     TEDoTextUPP = UniversalProcPtr;
  241.     TEClickLoopUPP = UniversalProcPtr;
  242.     WordBreakUPP = UniversalProcPtr;
  243.     TERec = RECORD
  244.         destRect:                Rect;
  245.         viewRect:                Rect;
  246.         selRect:                Rect;
  247.         lineHeight:                INTEGER;
  248.         fontAscent:                INTEGER;
  249.         selPoint:                Point;
  250.         selStart:                INTEGER;
  251.         selEnd:                    INTEGER;
  252.         active:                    INTEGER;
  253.         wordBreak:                WordBreakUPP;
  254.         clickLoop:                TEClickLoopUPP;
  255.         clickTime:                LONGINT;
  256.         clickLoc:                INTEGER;
  257.         caretTime:                LONGINT;
  258.         caretState:                INTEGER;
  259.         just:                    INTEGER;
  260.         teLength:                INTEGER;
  261.         hText:                    Handle;
  262.         hDispatchRec:            LONGINT;                                {  added to replace recalBack & recalLines.  it's a handle anyway  }
  263.         clikStuff:                INTEGER;
  264.         crOnly:                    INTEGER;
  265.         txFont:                    INTEGER;
  266.         txFace:                    StyleField;                                { txFace is unpacked byte }
  267.         txMode:                    INTEGER;
  268.         txSize:                    INTEGER;
  269.         inPort:                    GrafPtr;
  270.         highHook:                HighHookUPP;
  271.         caretHook:                CaretHookUPP;
  272.         nLines:                    INTEGER;
  273.         lineStarts:                ARRAY [0..16000] OF INTEGER;
  274.     END;
  275.  
  276.  
  277. CONST
  278.                                                                 {  Justification (word alignment) styles  }
  279.     teJustLeft                    = 0;
  280.     teJustCenter                = 1;
  281.     teJustRight                    = -1;
  282.     teForceLeft                    = -2;                            {  new names for the Justification (word alignment) styles  }
  283.     teFlushDefault                = 0;                            { flush according to the line direction  }
  284.     teCenter                    = 1;                            { center justify (word alignment)  }
  285.     teFlushRight                = -1;                            { flush right for all scripts  }
  286.     teFlushLeft                    = -2;                            { flush left for all scripts  }
  287.                                                                 {  Set/Replace style modes  }
  288.     fontBit                        = 0;                            { set font }
  289.     faceBit                        = 1;                            { set face }
  290.     sizeBit                        = 2;                            { set size }
  291.     clrBit                        = 3;                            { set color }
  292.     addSizeBit                    = 4;                            { add size mode }
  293.     toggleBit                    = 5;                            { set faces in toggle mode }
  294.                                                                 {  TESetStyle/TEContinuousStyle modes  }
  295.     doFont                        = 1;                            {  set font (family) number }
  296.     doFace                        = 2;                            { set character style }
  297.     doSize                        = 4;                            { set type size }
  298.     doColor                        = 8;                            { set color }
  299.     doAll                        = 15;                            { set all attributes }
  300.     addSize                        = 16;                            { adjust type size }
  301.  
  302.     doToggle                    = 32;                            { toggle mode for TESetStyle }
  303.                                                                 {  offsets into TEDispatchRec  }
  304.     EOLHook                        = 0;                            { [UniversalProcPtr] TEEOLHook }
  305.     DRAWHook                    = 4;                            { [UniversalProcPtr] TEWidthHook }
  306.     WIDTHHook                    = 8;                            { [UniversalProcPtr] TEDrawHook }
  307.     HITTESTHook                    = 12;                            { [UniversalProcPtr] TEHitTestHook }
  308.     nWIDTHHook                    = 24;                            { [UniversalProcPtr] nTEWidthHook }
  309.     TextWidthHook                = 28;                            { [UniversalProcPtr] TETextWidthHook }
  310.                                                                 {  selectors for TECustomHook  }
  311.     intEOLHook                    = 0;                            { TEIntHook value }
  312.     intDrawHook                    = 1;                            { TEIntHook value }
  313.     intWidthHook                = 2;                            { TEIntHook value }
  314.     intHitTestHook                = 3;                            { TEIntHook value }
  315.     intNWidthHook                = 6;                            { TEIntHook value for new version of WidthHook }
  316.     intTextWidthHook            = 7;                            { TEIntHook value for new TextWidthHook }
  317.     intInlineInputTSMTEPreUpdateHook = 8;                        { TEIntHook value for TSMTEPreUpdateProcPtr callback }
  318.     intInlineInputTSMTEPostUpdateHook = 9;                        { TEIntHook value for TSMTEPostUpdateProcPtr callback }
  319.                                                                 {  feature or bit definitions for TEFeatureFlag  }
  320.     teFAutoScroll                = 0;                            { 00000001b }
  321.     teFTextBuffering            = 1;                            { 00000010b }
  322.     teFOutlineHilite            = 2;                            { 00000100b }
  323.     teFInlineInput                = 3;                            { 00001000b  }
  324.                                                                 {     teFUseTextServices    is obsolete as of System 8.                     }
  325.     teFUseInlineInput            = 5;                            { 00100000b  }
  326.     teFInlineInputAutoScroll    = 6;                            { 01000000b  }
  327.  
  328.                                                                 {  action for the new "bit (un)set" interface, TEFeatureFlag  }
  329.     teBitClear                    = 0;
  330.     teBitSet                    = 1;                            { set the selector bit }
  331.     teBitTest                    = -1;                            { no change; just return the current setting }
  332.                                                                 { constants for identifying the routine that called FindWord  }
  333.     teWordSelect                = 4;                            { clickExpand to select word }
  334.     teWordDrag                    = 8;                            { clickExpand to drag new word }
  335.     teFromFind                    = 12;                            { FindLine called it ($0C) }
  336.     teFromRecal                    = 16;                            { RecalLines called it ($10)      obsolete  }
  337.                                                                 { constants for identifying TEDoText selectors  }
  338.     teFind                        = 0;                            { TEDoText called for searching }
  339.     teHighlight                    = 1;                            { TEDoText called for highlighting }
  340.     teDraw                        = -1;                            { TEDoText called for drawing text }
  341.     teCaret                        = -2;                            { TEDoText called for drawing the caret }
  342.  
  343.  
  344. TYPE
  345.     Chars                                = PACKED ARRAY [0..32000] OF CHAR;
  346.     CharsPtr                            = ^Chars;
  347.     CharsHandle                            = ^CharsPtr;
  348.     StyleRunPtr = ^StyleRun;
  349.     StyleRun = RECORD
  350.         startChar:                INTEGER;                                { starting character position }
  351.         styleIndex:                INTEGER;                                { index in style table }
  352.     END;
  353.  
  354.     STElementPtr = ^STElement;
  355.     STElement = RECORD
  356.         stCount:                INTEGER;                                { number of runs in this style }
  357.         stHeight:                INTEGER;                                { line height }
  358.         stAscent:                INTEGER;                                { font ascent }
  359.         stFont:                    INTEGER;                                { font (family) number }
  360.         stFace:                    StyleField;                                { character Style }
  361.         stSize:                    INTEGER;                                { size in points }
  362.         stColor:                RGBColor;                                { absolute (RGB) color }
  363.     END;
  364.  
  365.     TEStyleTable                        = ARRAY [0..1776] OF STElement;
  366.     STPtr                                = ^TEStyleTable;
  367.     STHandle                            = ^STPtr;
  368.     LHElementPtr = ^LHElement;
  369.     LHElement = RECORD
  370.         lhHeight:                INTEGER;                                { maximum height in line }
  371.         lhAscent:                INTEGER;                                { maximum ascent in line }
  372.     END;
  373.  
  374.     LHTable                                = ARRAY [0..8000] OF LHElement;
  375.     LHPtr                                = ^LHTable;
  376.     LHHandle                            = ^LHPtr;
  377.     ScrpSTElementPtr = ^ScrpSTElement;
  378.     ScrpSTElement = RECORD
  379.         scrpStartChar:            LONGINT;                                { starting character position }
  380.         scrpHeight:                INTEGER;
  381.         scrpAscent:                INTEGER;
  382.         scrpFont:                INTEGER;
  383.         scrpFace:                StyleField;                                { unpacked byte }
  384.         scrpSize:                INTEGER;
  385.         scrpColor:                RGBColor;
  386.     END;
  387.  
  388. {  ARRAY [0..1600] OF ScrpSTElement  }
  389.     ScrpSTTable                            = ARRAY [0..1600] OF ScrpSTElement;
  390.     StScrpRecPtr = ^StScrpRec;
  391.     StScrpRec = RECORD
  392.         scrpNStyles:            INTEGER;                                { number of styles in scrap }
  393.         scrpStyleTab:            ScrpSTTable;                            { table of styles for scrap }
  394.     END;
  395.  
  396.     StScrpPtr                            = ^StScrpRec;
  397.     StScrpHandle                        = ^StScrpPtr;
  398.     NullStRecPtr = ^NullStRec;
  399.     NullStRec = RECORD
  400.         teReserved:                LONGINT;                                { reserved for future expansion }
  401.         nullScrap:                StScrpHandle;                            { handle to scrap style table }
  402.     END;
  403.  
  404.     NullStPtr                            = ^NullStRec;
  405.     NullStHandle                        = ^NullStPtr;
  406.     TEStyleRecPtr = ^TEStyleRec;
  407.     TEStyleRec = RECORD
  408.         nRuns:                    INTEGER;                                { number of style runs }
  409.         nStyles:                INTEGER;                                { size of style table }
  410.         styleTab:                STHandle;                                { handle to style table }
  411.         lhTab:                    LHHandle;                                { handle to line-height table }
  412.         teRefCon:                LONGINT;                                { reserved for application use }
  413.         nullStyle:                NullStHandle;                            { Handle to style set at null selection }
  414.         runs:                    ARRAY [0..8000] OF StyleRun;            { ARRAY [0..8000] OF StyleRun }
  415.     END;
  416.  
  417.     TEStylePtr                            = ^TEStyleRec;
  418.     TEStyleHandle                        = ^TEStylePtr;
  419.     TextStylePtr = ^TextStyle;
  420.     TextStyle = RECORD
  421.         tsFont:                    INTEGER;                                { font (family) number }
  422.         tsFace:                    StyleField;                                { character Style }
  423.         tsSize:                    INTEGER;                                { size in point }
  424.         tsColor:                RGBColor;                                { absolute (RGB) color }
  425.     END;
  426.  
  427.     TextStyleHandle                        = ^TextStylePtr;
  428.     TEIntHook                            = INTEGER;
  429.  
  430. CONST
  431.     uppHighHookProcInfo = $0000000F;
  432.     uppEOLHookProcInfo = $0000001F;
  433.     uppCaretHookProcInfo = $0000000F;
  434.     uppWidthHookProcInfo = $0000002F;
  435.     uppTextWidthHookProcInfo = $0000002F;
  436.     uppNWidthHookProcInfo = $0000003F;
  437.     uppDrawHookProcInfo = $0000004F;
  438.     uppHitTestHookProcInfo = $0000005F;
  439.     uppTEFindWordProcInfo = $0000006F;
  440.     uppTERecalcProcInfo = $0000009F;
  441.     uppTEDoTextProcInfo = $000000AF;
  442.     uppTEClickLoopProcInfo = $0000F812;
  443.     uppWordBreakProcInfo = $00029812;
  444.  
  445. FUNCTION NewHighHookProc(userRoutine: HighHookProcPtr): HighHookUPP;
  446.     {$IFC NOT GENERATINGCFM }
  447.     INLINE $2E9F;
  448.     {$ENDC}
  449.  
  450. FUNCTION NewEOLHookProc(userRoutine: EOLHookProcPtr): EOLHookUPP;
  451.     {$IFC NOT GENERATINGCFM }
  452.     INLINE $2E9F;
  453.     {$ENDC}
  454.  
  455. FUNCTION NewCaretHookProc(userRoutine: CaretHookProcPtr): CaretHookUPP;
  456.     {$IFC NOT GENERATINGCFM }
  457.     INLINE $2E9F;
  458.     {$ENDC}
  459.  
  460. FUNCTION NewWidthHookProc(userRoutine: WidthHookProcPtr): WidthHookUPP;
  461.     {$IFC NOT GENERATINGCFM }
  462.     INLINE $2E9F;
  463.     {$ENDC}
  464.  
  465. FUNCTION NewTextWidthHookProc(userRoutine: TextWidthHookProcPtr): TextWidthHookUPP;
  466.     {$IFC NOT GENERATINGCFM }
  467.     INLINE $2E9F;
  468.     {$ENDC}
  469.  
  470. FUNCTION NewNWidthHookProc(userRoutine: NWidthHookProcPtr): NWidthHookUPP;
  471.     {$IFC NOT GENERATINGCFM }
  472.     INLINE $2E9F;
  473.     {$ENDC}
  474.  
  475. FUNCTION NewDrawHookProc(userRoutine: DrawHookProcPtr): DrawHookUPP;
  476.     {$IFC NOT GENERATINGCFM }
  477.     INLINE $2E9F;
  478.     {$ENDC}
  479.  
  480. FUNCTION NewHitTestHookProc(userRoutine: HitTestHookProcPtr): HitTestHookUPP;
  481.     {$IFC NOT GENERATINGCFM }
  482.     INLINE $2E9F;
  483.     {$ENDC}
  484.  
  485. FUNCTION NewTEFindWordProc(userRoutine: TEFindWordProcPtr): TEFindWordUPP;
  486.     {$IFC NOT GENERATINGCFM }
  487.     INLINE $2E9F;
  488.     {$ENDC}
  489.  
  490. FUNCTION NewTERecalcProc(userRoutine: TERecalcProcPtr): TERecalcUPP;
  491.     {$IFC NOT GENERATINGCFM }
  492.     INLINE $2E9F;
  493.     {$ENDC}
  494.  
  495. FUNCTION NewTEDoTextProc(userRoutine: TEDoTextProcPtr): TEDoTextUPP;
  496.     {$IFC NOT GENERATINGCFM }
  497.     INLINE $2E9F;
  498.     {$ENDC}
  499.  
  500. FUNCTION NewTEClickLoopProc(userRoutine: TEClickLoopProcPtr): TEClickLoopUPP;
  501.     {$IFC NOT GENERATINGCFM }
  502.     INLINE $2E9F;
  503.     {$ENDC}
  504.  
  505. FUNCTION NewWordBreakProc(userRoutine: WordBreakProcPtr): WordBreakUPP;
  506.     {$IFC NOT GENERATINGCFM }
  507.     INLINE $2E9F;
  508.     {$ENDC}
  509.  
  510. PROCEDURE CallHighHookProc({CONST}VAR r: Rect; pTE: TEPtr; userRoutine: HighHookUPP);
  511.     {$IFC NOT GENERATINGCFM}
  512.     {To be implemented:  Glue to move parameters into registers.}
  513.     {$ENDC}
  514.  
  515. FUNCTION CallEOLHookProc(theChar: ByteParameter; pTE: TEPtr; hTE: TEHandle; userRoutine: EOLHookUPP): BOOLEAN;
  516.     {$IFC NOT GENERATINGCFM}
  517.     {To be implemented:  Glue to move parameters into registers.}
  518.     {$ENDC}
  519.  
  520. PROCEDURE CallCaretHookProc({CONST}VAR r: Rect; pTE: TEPtr; userRoutine: CaretHookUPP);
  521.     {$IFC NOT GENERATINGCFM}
  522.     {To be implemented:  Glue to move parameters into registers.}
  523.     {$ENDC}
  524.  
  525. FUNCTION CallWidthHookProc(textLen: INTEGER; textOffset: INTEGER; textBufferPtr: UNIV Ptr; pTE: TEPtr; hTE: TEHandle; userRoutine: WidthHookUPP): INTEGER;
  526.     {$IFC NOT GENERATINGCFM}
  527.     {To be implemented:  Glue to move parameters into registers.}
  528.     {$ENDC}
  529.  
  530. FUNCTION CallTextWidthHookProc(textLen: INTEGER; textOffset: INTEGER; textBufferPtr: UNIV Ptr; pTE: TEPtr; hTE: TEHandle; userRoutine: TextWidthHookUPP): INTEGER;
  531.     {$IFC NOT GENERATINGCFM}
  532.     {To be implemented:  Glue to move parameters into registers.}
  533.     {$ENDC}
  534.  
  535. FUNCTION CallNWidthHookProc(styleRunLen: INTEGER; styleRunOffset: INTEGER; slop: INTEGER; direction: INTEGER; textBufferPtr: UNIV Ptr; VAR lineStart: INTEGER; pTE: TEPtr; hTE: TEHandle; userRoutine: NWidthHookUPP): INTEGER;
  536.     {$IFC NOT GENERATINGCFM}
  537.     {To be implemented:  Glue to move parameters into registers.}
  538.     {$ENDC}
  539.  
  540. PROCEDURE CallDrawHookProc(textOffset: INTEGER; drawLen: INTEGER; textBufferPtr: UNIV Ptr; pTE: TEPtr; hTE: TEHandle; userRoutine: DrawHookUPP);
  541.     {$IFC NOT GENERATINGCFM}
  542.     {To be implemented:  Glue to move parameters into registers.}
  543.     {$ENDC}
  544.  
  545. FUNCTION CallHitTestHookProc(styleRunLen: INTEGER; styleRunOffset: INTEGER; slop: INTEGER; textBufferPtr: UNIV Ptr; pTE: TEPtr; hTE: TEHandle; VAR pixelWidth: INTEGER; VAR charOffset: INTEGER; VAR pixelInChar: BOOLEAN; userRoutine: HitTestHookUPP): BOOLEAN;
  546.     {$IFC NOT GENERATINGCFM}
  547.     {To be implemented:  Glue to move parameters into registers.}
  548.     {$ENDC}
  549.  
  550. PROCEDURE CallTEFindWordProc(currentPos: INTEGER; caller: INTEGER; pTE: TEPtr; hTE: TEHandle; VAR wordStart: INTEGER; VAR wordEnd: INTEGER; userRoutine: TEFindWordUPP);
  551.     {$IFC NOT GENERATINGCFM}
  552.     {To be implemented:  Glue to move parameters into registers.}
  553.     {$ENDC}
  554.  
  555. PROCEDURE CallTERecalcProc(pTE: TEPtr; changeLength: INTEGER; VAR lineStart: INTEGER; VAR firstChar: INTEGER; VAR lastChar: INTEGER; userRoutine: TERecalcUPP);
  556.     {$IFC NOT GENERATINGCFM}
  557.     {To be implemented:  Glue to move parameters into registers.}
  558.     {$ENDC}
  559.  
  560. PROCEDURE CallTEDoTextProc(pTE: TEPtr; firstChar: INTEGER; lastChar: INTEGER; selector: INTEGER; VAR currentGrafPort: GrafPtr; VAR charPosition: INTEGER; userRoutine: TEDoTextUPP);
  561.     {$IFC NOT GENERATINGCFM}
  562.     {To be implemented:  Glue to move parameters into registers.}
  563.     {$ENDC}
  564.  
  565. FUNCTION CallTEClickLoopProc(pTE: TEPtr; userRoutine: TEClickLoopUPP): BOOLEAN;
  566.     {$IFC NOT GENERATINGCFM}
  567.     {To be implemented:  Glue to move parameters into registers.}
  568.     {$ENDC}
  569.  
  570. FUNCTION CallWordBreakProc(text: Ptr; charPos: INTEGER; userRoutine: WordBreakUPP): BOOLEAN;
  571.     {$IFC NOT GENERATINGCFM}
  572.     {To be implemented:  Glue to move parameters into registers.}
  573.     {$ENDC}
  574. {$ENDC}
  575. {$IFC FOR_SYSTEM8_COOPERATIVE }
  576.  
  577. TYPE
  578.     TEPreUpdateProcPtr = ProcPtr;  { PROCEDURE TEPreUpdate(textH: TEHandle; context: TSMContext; refCon: LONGINT); }
  579.  
  580.     TEPostUpdateProcPtr = ProcPtr;  { PROCEDURE TEPostUpdate(textH: TEHandle; context: TSMContext; theText: TextObject; fixLen: LONGINT; inputAreaStart: LONGINT; inputAreaEnd: LONGINT; pinStart: LONGINT; pinEnd: LONGINT; refCon: LONGINT); }
  581.  
  582.     TEPreUpdateUPP = UniversalProcPtr;
  583.     TEPostUpdateUPP = UniversalProcPtr;
  584.  
  585. CONST
  586.     uppTEPreUpdateProcInfo = $00000FC0;
  587.     uppTEPostUpdateProcInfo = $00FFFFC0;
  588.  
  589. FUNCTION NewTEPreUpdateProc(userRoutine: TEPreUpdateProcPtr): TEPreUpdateUPP;
  590.     {$IFC NOT GENERATINGCFM }
  591.     INLINE $2E9F;
  592.     {$ENDC}
  593.  
  594. FUNCTION NewTEPostUpdateProc(userRoutine: TEPostUpdateProcPtr): TEPostUpdateUPP;
  595.     {$IFC NOT GENERATINGCFM }
  596.     INLINE $2E9F;
  597.     {$ENDC}
  598.  
  599. PROCEDURE CallTEPreUpdateProc(textH: TEHandle; context: TSMContext; refCon: LONGINT; userRoutine: TEPreUpdateUPP);
  600.     {$IFC NOT GENERATINGCFM}
  601.     INLINE $205F, $4E90;
  602.     {$ENDC}
  603.  
  604. PROCEDURE CallTEPostUpdateProc(textH: TEHandle; context: TSMContext; theText: TextObject; fixLen: LONGINT; inputAreaStart: LONGINT; inputAreaEnd: LONGINT; pinStart: LONGINT; pinEnd: LONGINT; refCon: LONGINT; userRoutine: TEPostUpdateUPP);
  605.     {$IFC NOT GENERATINGCFM}
  606.     INLINE $205F, $4E90;
  607.     {$ENDC}
  608.  
  609. CONST
  610.                                                                 {  feature or bit definitions for TEFeatureFlag System 8  }
  611.     teFEnableInteractiveServices = 7;                            { 10000000b  }
  612.                                                                 {  selectors for TECustomHook  }
  613.     intInlineInputPreUpdateHook    = 10;                            { TEIntHook value for TEPreUpdateProcPtr callback }
  614.     intInlineInputPostUpdateHook = 11;                            { TEIntHook value for TEPostUpdateProcPtr callback }
  615.  
  616. {$ENDC}
  617. {$IFC FOR_SYSTEM7_ONLY }
  618.  
  619. CONST
  620.                                                                 {  feature bit 4 for TEFeatureFlag no longer in use  }
  621.     teFUseTextServices            = 4;                            { 00010000b  }
  622.  
  623. {$ENDC}
  624. {$IFC FOR_SYSTEM7_AND_SYSTEM8_COOPERATIVE }
  625. FUNCTION TEScrapHandle: Handle;
  626.     {$IFC NOT GENERATINGCFM}
  627.     INLINE $2EB8, $0AB4;
  628.     {$ENDC}
  629. FUNCTION TEGetScrapLength: LONGINT;
  630. PROCEDURE TEInit;
  631.     {$IFC NOT GENERATINGCFM}
  632.     INLINE $A9CC;
  633.     {$ENDC}
  634. FUNCTION TENew({CONST}VAR destRect: Rect; {CONST}VAR viewRect: Rect): TEHandle;
  635.     {$IFC NOT GENERATINGCFM}
  636.     INLINE $A9D2;
  637.     {$ENDC}
  638. PROCEDURE TEDispose(hTE: TEHandle);
  639.     {$IFC NOT GENERATINGCFM}
  640.     INLINE $A9CD;
  641.     {$ENDC}
  642. PROCEDURE TESetText(text: UNIV Ptr; length: LONGINT; hTE: TEHandle);
  643.     {$IFC NOT GENERATINGCFM}
  644.     INLINE $A9CF;
  645.     {$ENDC}
  646. FUNCTION TEGetText(hTE: TEHandle): CharsHandle;
  647.     {$IFC NOT GENERATINGCFM}
  648.     INLINE $A9CB;
  649.     {$ENDC}
  650. PROCEDURE TEIdle(hTE: TEHandle);
  651.     {$IFC NOT GENERATINGCFM}
  652.     INLINE $A9DA;
  653.     {$ENDC}
  654. PROCEDURE TESetSelect(selStart: LONGINT; selEnd: LONGINT; hTE: TEHandle);
  655.     {$IFC NOT GENERATINGCFM}
  656.     INLINE $A9D1;
  657.     {$ENDC}
  658. PROCEDURE TEActivate(hTE: TEHandle);
  659.     {$IFC NOT GENERATINGCFM}
  660.     INLINE $A9D8;
  661.     {$ENDC}
  662. PROCEDURE TEDeactivate(hTE: TEHandle);
  663.     {$IFC NOT GENERATINGCFM}
  664.     INLINE $A9D9;
  665.     {$ENDC}
  666. PROCEDURE TEKey(key: CharParameter; hTE: TEHandle);
  667.     {$IFC NOT GENERATINGCFM}
  668.     INLINE $A9DC;
  669.     {$ENDC}
  670. PROCEDURE TECut(hTE: TEHandle);
  671.     {$IFC NOT GENERATINGCFM}
  672.     INLINE $A9D6;
  673.     {$ENDC}
  674. PROCEDURE TECopy(hTE: TEHandle);
  675.     {$IFC NOT GENERATINGCFM}
  676.     INLINE $A9D5;
  677.     {$ENDC}
  678. PROCEDURE TEPaste(hTE: TEHandle);
  679.     {$IFC NOT GENERATINGCFM}
  680.     INLINE $A9DB;
  681.     {$ENDC}
  682. PROCEDURE TEDelete(hTE: TEHandle);
  683.     {$IFC NOT GENERATINGCFM}
  684.     INLINE $A9D7;
  685.     {$ENDC}
  686. PROCEDURE TEInsert(text: UNIV Ptr; length: LONGINT; hTE: TEHandle);
  687.     {$IFC NOT GENERATINGCFM}
  688.     INLINE $A9DE;
  689.     {$ENDC}
  690. PROCEDURE TESetAlignment(just: INTEGER; hTE: TEHandle);
  691.     {$IFC NOT GENERATINGCFM}
  692.     INLINE $A9DF;
  693.     {$ENDC}
  694. PROCEDURE TEUpdate({CONST}VAR rUpdate: Rect; hTE: TEHandle);
  695.     {$IFC NOT GENERATINGCFM}
  696.     INLINE $A9D3;
  697.     {$ENDC}
  698. PROCEDURE TETextBox(text: UNIV Ptr; length: LONGINT; {CONST}VAR box: Rect; just: INTEGER);
  699.     {$IFC NOT GENERATINGCFM}
  700.     INLINE $A9CE;
  701.     {$ENDC}
  702. PROCEDURE TEScroll(dh: INTEGER; dv: INTEGER; hTE: TEHandle);
  703.     {$IFC NOT GENERATINGCFM}
  704.     INLINE $A9DD;
  705.     {$ENDC}
  706. PROCEDURE TESelView(hTE: TEHandle);
  707.     {$IFC NOT GENERATINGCFM}
  708.     INLINE $A811;
  709.     {$ENDC}
  710. PROCEDURE TEPinScroll(dh: INTEGER; dv: INTEGER; hTE: TEHandle);
  711.     {$IFC NOT GENERATINGCFM}
  712.     INLINE $A812;
  713.     {$ENDC}
  714. PROCEDURE TEAutoView(fAuto: BOOLEAN; hTE: TEHandle);
  715.     {$IFC NOT GENERATINGCFM}
  716.     INLINE $A813;
  717.     {$ENDC}
  718. PROCEDURE TECalText(hTE: TEHandle);
  719.     {$IFC NOT GENERATINGCFM}
  720.     INLINE $A9D0;
  721.     {$ENDC}
  722. FUNCTION TEGetOffset(pt: Point; hTE: TEHandle): INTEGER;
  723.     {$IFC NOT GENERATINGCFM}
  724.     INLINE $A83C;
  725.     {$ENDC}
  726. FUNCTION TEGetPoint(offset: INTEGER; hTE: TEHandle): Point;
  727.     {$IFC NOT GENERATINGCFM}
  728.     INLINE $3F3C, $0008, $A83D;
  729.     {$ENDC}
  730. PROCEDURE TEClick(pt: Point; fExtend: BOOLEAN; h: TEHandle);
  731.     {$IFC NOT GENERATINGCFM}
  732.     INLINE $A9D4;
  733.     {$ENDC}
  734. FUNCTION TEStyleNew({CONST}VAR destRect: Rect; {CONST}VAR viewRect: Rect): TEHandle;
  735.     {$IFC NOT GENERATINGCFM}
  736.     INLINE $A83E;
  737.     {$ENDC}
  738. PROCEDURE TESetStyleHandle(theHandle: TEStyleHandle; hTE: TEHandle);
  739.     {$IFC NOT GENERATINGCFM}
  740.     INLINE $3F3C, $0005, $A83D;
  741.     {$ENDC}
  742. FUNCTION TEGetStyleHandle(hTE: TEHandle): TEStyleHandle;
  743.     {$IFC NOT GENERATINGCFM}
  744.     INLINE $3F3C, $0004, $A83D;
  745.     {$ENDC}
  746. PROCEDURE TEGetStyle(offset: INTEGER; VAR theStyle: TextStyle; VAR lineHeight: INTEGER; VAR fontAscent: INTEGER; hTE: TEHandle);
  747.     {$IFC NOT GENERATINGCFM}
  748.     INLINE $3F3C, $0003, $A83D;
  749.     {$ENDC}
  750. PROCEDURE TEStylePaste(hTE: TEHandle);
  751.     {$IFC NOT GENERATINGCFM}
  752.     INLINE $3F3C, $0000, $A83D;
  753.     {$ENDC}
  754. PROCEDURE TESetStyle(mode: INTEGER; {CONST}VAR newStyle: TextStyle; fRedraw: BOOLEAN; hTE: TEHandle);
  755.     {$IFC NOT GENERATINGCFM}
  756.     INLINE $3F3C, $0001, $A83D;
  757.     {$ENDC}
  758. PROCEDURE TEReplaceStyle(mode: INTEGER; {CONST}VAR oldStyle: TextStyle; {CONST}VAR newStyle: TextStyle; fRedraw: BOOLEAN; hTE: TEHandle);
  759.     {$IFC NOT GENERATINGCFM}
  760.     INLINE $3F3C, $0002, $A83D;
  761.     {$ENDC}
  762. FUNCTION TEGetStyleScrapHandle(hTE: TEHandle): StScrpHandle;
  763.     {$IFC NOT GENERATINGCFM}
  764.     INLINE $3F3C, $0006, $A83D;
  765.     {$ENDC}
  766. PROCEDURE TEStyleInsert(text: UNIV Ptr; length: LONGINT; hST: StScrpHandle; hTE: TEHandle);
  767.     {$IFC NOT GENERATINGCFM}
  768.     INLINE $3F3C, $0007, $A83D;
  769.     {$ENDC}
  770. FUNCTION TEGetHeight(endLine: LONGINT; startLine: LONGINT; hTE: TEHandle): LONGINT;
  771.     {$IFC NOT GENERATINGCFM}
  772.     INLINE $3F3C, $0009, $A83D;
  773.     {$ENDC}
  774. FUNCTION TEContinuousStyle(VAR mode: INTEGER; VAR aStyle: TextStyle; hTE: TEHandle): BOOLEAN;
  775.     {$IFC NOT GENERATINGCFM}
  776.     INLINE $3F3C, $000A, $A83D;
  777.     {$ENDC}
  778. PROCEDURE TEUseStyleScrap(rangeStart: LONGINT; rangeEnd: LONGINT; newStyles: StScrpHandle; fRedraw: BOOLEAN; hTE: TEHandle);
  779.     {$IFC NOT GENERATINGCFM}
  780.     INLINE $3F3C, $000B, $A83D;
  781.     {$ENDC}
  782. PROCEDURE TECustomHook(which: TEIntHook; VAR addr: UniversalProcPtr; hTE: TEHandle);
  783.     {$IFC NOT GENERATINGCFM}
  784.     INLINE $3F3C, $000C, $A83D;
  785.     {$ENDC}
  786. FUNCTION TENumStyles(rangeStart: LONGINT; rangeEnd: LONGINT; hTE: TEHandle): LONGINT;
  787.     {$IFC NOT GENERATINGCFM}
  788.     INLINE $3F3C, $000D, $A83D;
  789.     {$ENDC}
  790. FUNCTION TEFeatureFlag(feature: INTEGER; action: INTEGER; hTE: TEHandle): INTEGER;
  791.     {$IFC NOT GENERATINGCFM}
  792.     INLINE $3F3C, $000E, $A83D;
  793.     {$ENDC}
  794. FUNCTION TEGetHiliteRgn(region: RgnHandle; hTE: TEHandle): OSErr;
  795.     {$IFC NOT GENERATINGCFM}
  796.     INLINE $3F3C, $000F, $A83D;
  797.     {$ENDC}
  798. PROCEDURE TESetInlineInputContextPtr(hTE: TEHandle; contextPtr: UNIV Ptr);
  799.     {$IFC NOT GENERATINGCFM}
  800.     INLINE $3F3C, $0010, $A83D;
  801.     {$ENDC}
  802. PROCEDURE TEConfirmInlineInput(hTE: TEHandle);
  803.     {$IFC NOT GENERATINGCFM}
  804.     INLINE $3F3C, $0011, $A83D;
  805.     {$ENDC}
  806. PROCEDURE TESetScrapLength(length: LONGINT);
  807. FUNCTION TEFromScrap: OSErr;
  808. FUNCTION TEToScrap: OSErr;
  809. PROCEDURE TESetClickLoop(clikProc: TEClickLoopUPP; hTE: TEHandle);
  810. PROCEDURE TESetWordBreak(wBrkProc: WordBreakUPP; hTE: TEHandle);
  811. FUNCTION TEInsertTextObject(hTE: TEHandle; textObject: ConstTextObject; startIndex: TextObjectIndex; endIndex: TextObjectIndex; insertionStart: LONGINT; insertionEnd: LONGINT; fontSelectionOption: OptionBits): OSStatus;
  812.     {$IFC NOT GENERATINGCFM}
  813.     INLINE $3F3C, $0012, $A83D;
  814.     {$ENDC}
  815. FUNCTION TEExtractTextObject(hTE: TEHandle; oldTextObject: TextObject; VAR newTextObject: TextObject; textStart: LONGINT; textEnd: LONGINT): OSStatus;
  816.     {$IFC NOT GENERATINGCFM}
  817.     INLINE $3F3C, $0013, $A83D;
  818.     {$ENDC}
  819. {$ENDC}
  820. {$IFC FOR_SYSTEM8_COOPERATIVE }
  821. {
  822.     TEHandleModernAE is mostly for use by SWM to allow TSM to manage the TextEdit region
  823.     to be handled by TextEdit.
  824. }
  825. {$IFC FOR_PTR_BASED_AE }
  826. FUNCTION TEHandleModernAE({CONST}VAR theAppleEvent: AppleEvent; VAR reply: AppleEvent; refCon: UNIV Ptr; handlerTable: AEHandlerTableRef): OSStatus;
  827. {$ENDC}
  828. FUNCTION TEGetDoTextHook: UniversalProcPtr;
  829. PROCEDURE TESetDoTextHook(value: UniversalProcPtr);
  830. FUNCTION TEGetRecalcHook: UniversalProcPtr;
  831. PROCEDURE TESetRecalcHook(value: UniversalProcPtr);
  832. FUNCTION TEGetFindWordHook: UniversalProcPtr;
  833. PROCEDURE TESetFindWordHook(value: UniversalProcPtr);
  834. FUNCTION TEGetScrapHandle: Handle;
  835. PROCEDURE TESetScrapHandle(value: Handle);
  836. {$ENDC}
  837. {$IFC OLDROUTINENAMES }
  838. {$IFC FOR_SYSTEM7_AND_SYSTEM8_DEPRECATED }
  839. PROCEDURE TESetJust(just: INTEGER; hTE: TEHandle);
  840.     {$IFC NOT GENERATINGCFM}
  841.     INLINE $A9DF;
  842.     {$ENDC}
  843. PROCEDURE TextBox(text: UNIV Ptr; length: LONGINT; {CONST}VAR box: Rect; just: INTEGER);
  844.     {$IFC NOT GENERATINGCFM}
  845.     INLINE $A9CE;
  846.     {$ENDC}
  847. FUNCTION TEStylNew({CONST}VAR destRect: Rect; {CONST}VAR viewRect: Rect): TEHandle;
  848.     {$IFC NOT GENERATINGCFM}
  849.     INLINE $A83E;
  850.     {$ENDC}
  851. PROCEDURE SetStylHandle(theHandle: TEStyleHandle; hTE: TEHandle);
  852.     {$IFC NOT GENERATINGCFM}
  853.     INLINE $3F3C, $0005, $A83D;
  854.     {$ENDC}
  855. PROCEDURE SetStyleHandle(theHandle: TEStyleHandle; hTE: TEHandle);
  856.     {$IFC NOT GENERATINGCFM}
  857.     INLINE $3F3C, $0005, $A83D;
  858.     {$ENDC}
  859. FUNCTION GetStylHandle(hTE: TEHandle): TEStyleHandle;
  860.     {$IFC NOT GENERATINGCFM}
  861.     INLINE $3F3C, $0004, $A83D;
  862.     {$ENDC}
  863. FUNCTION GetStyleHandle(hTE: TEHandle): TEStyleHandle;
  864.     {$IFC NOT GENERATINGCFM}
  865.     INLINE $3F3C, $0004, $A83D;
  866.     {$ENDC}
  867. PROCEDURE TEStylPaste(hTE: TEHandle);
  868.     {$IFC NOT GENERATINGCFM}
  869.     INLINE $3F3C, $0000, $A83D;
  870.     {$ENDC}
  871. FUNCTION GetStylScrap(hTE: TEHandle): StScrpHandle;
  872.     {$IFC NOT GENERATINGCFM}
  873.     INLINE $3F3C, $0006, $A83D;
  874.     {$ENDC}
  875. FUNCTION GetStyleScrap(hTE: TEHandle): StScrpHandle;
  876.     {$IFC NOT GENERATINGCFM}
  877.     INLINE $3F3C, $0006, $A83D;
  878.     {$ENDC}
  879. PROCEDURE SetStylScrap(rangeStart: LONGINT; rangeEnd: LONGINT; newStyles: StScrpHandle; fRedraw: BOOLEAN; hTE: TEHandle);
  880.     {$IFC NOT GENERATINGCFM}
  881.     INLINE $3F3C, $000B, $A83D;
  882.     {$ENDC}
  883. PROCEDURE SetStyleScrap(rangeStart: LONGINT; rangeEnd: LONGINT; newStyles: StScrpHandle; fRedraw: BOOLEAN; hTE: TEHandle);
  884.     {$IFC NOT GENERATINGCFM}
  885.     INLINE $3F3C, $000B, $A83D;
  886.     {$ENDC}
  887. PROCEDURE TEStylInsert(text: UNIV Ptr; length: LONGINT; hST: StScrpHandle; hTE: TEHandle);
  888.     {$IFC NOT GENERATINGCFM}
  889.     INLINE $3F3C, $0007, $A83D;
  890.     {$ENDC}
  891. PROCEDURE TESetScrapLen(length: LONGINT);
  892. FUNCTION TEGetScrapLen: LONGINT;
  893. PROCEDURE SetClikLoop(clikProc: TEClickLoopUPP; hTE: TEHandle);
  894. PROCEDURE SetWordBreak(wBrkProc: WordBreakUPP; hTE: TEHandle);
  895. {$ENDC}
  896. {$ENDC}
  897. {$ALIGN RESET}
  898. {$POP}
  899.  
  900. {$SETC UsingIncludes := TextEditIncludes}
  901.  
  902. {$ENDC} {__TEXTEDIT__}
  903.  
  904. {$IFC NOT UsingIncludes}
  905.  END.
  906. {$ENDC}
  907.